(function webpackUniversalModuleDefinition(root, factory) {
  if (typeof exports === 'object' && typeof module === 'object')
    module.exports = factory();
  else if (typeof define === 'function' && define.amd)
    define([], factory);
  else if (typeof exports === 'object')
    exports["POWERMODE"] = factory();
  else
    root["POWERMODE"] = factory();
})(this, function () {
  return /******/ (function (modules) { // webpackBootstrap
    /******/ // The module cache
    /******/
    var installedModules = {};

    /******/ // The require function
    /******/
    function __webpack_require__(moduleId) {

      /******/ // Check if module is in cache
      /******/
      if (installedModules[moduleId])
        /******/
        return installedModules[moduleId].exports;

      /******/ // Create a new module (and put it into the cache)
      /******/
      var module = installedModules[moduleId] = {
        /******/
        exports: {},
        /******/
        id: moduleId,
        /******/
        loaded: false
        /******/
      };

      /******/ // Execute the module function
      /******/
      modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

      /******/ // Flag the module as loaded
      /******/
      module.loaded = true;

      /******/ // Return the exports of the module
      /******/
      return module.exports;
      /******/
    }

    /******/ // expose the modules object (__webpack_modules__)
    /******/
    __webpack_require__.m = modules;

    /******/ // expose the module cache
    /******/
    __webpack_require__.c = installedModules;

    /******/ // __webpack_public_path__
    /******/
    __webpack_require__.p = "";

    /******/ // Load entry module and return exports
    /******/
    return __webpack_require__(0);
    /******/
  })
  /************************************************************************/
  /******/
  ([
    /* 0 */
    /***/
    (function (module, exports, __webpack_require__) {

      'use strict';

      var canvas = document.createElement('canvas');
      canvas.width = window.innerWidth;
      canvas.height = window.innerHeight;
      canvas.style.cssText = 'position:fixed;top:0;left:0;pointer-events:none;z-index:999999';
      window.addEventListener('resize', function () {
        canvas.width = window.innerWidth;
        canvas.height = window.innerHeight;
      });
      document.body.appendChild(canvas);
      var context = canvas.getContext('2d');
      var particles = [];
      var particlePointer = 0;
      var rendering = false;

      POWERMODE.shake = true;

      function getRandom(min, max) {
        return Math.random() * (max - min) + min;
      }

      function getColor(el) {
        if (POWERMODE.colorful) {
          var u = getRandom(0, 360);
          return 'hsla(' + getRandom(u - 10, u + 10) + ', 100%, ' + getRandom(50, 80) + '%, ' + 1 + ')';
        } else {
          return window.getComputedStyle(el).color;
        }
      }

      function getCaret() {
        var el = document.activeElement;
        var bcr;
        if (el.tagName === 'TEXTAREA' ||
          (el.tagName === 'INPUT' && el.getAttribute('type') === 'text')) {
          var offset = __webpack_require__(1)(el, el.selectionEnd);
          bcr = el.getBoundingClientRect();
          return {
            x: offset.left + bcr.left,
            y: offset.top + bcr.top,
            color: getColor(el)
          };
        }
        var selection = window.getSelection();
        if (selection.rangeCount) {
          var range = selection.getRangeAt(0);
          var startNode = range.startContainer;
          if (startNode.nodeType === document.TEXT_NODE) {
            startNode = startNode.parentNode;
          }
          bcr = range.getBoundingClientRect();
          return {
            x: bcr.left,
            y: bcr.top,
            color: getColor(startNode)
          };
        }
        return {
          x: 0,
          y: 0,
          color: 'transparent'
        };
      }

      function createParticle(x, y, color) {
        return {
          x: x,
          y: y,
          alpha: 1,
          color: color,
          velocity: {
            x: -1 + Math.random() * 2,
            y: -3.5 + Math.random() * 2
          }
        };
      }

      function POWERMODE() {
        { // spawn particles
          var caret = getCaret();
          var numParticles = 5 + Math.round(Math.random() * 10);
          while (numParticles--) {
            particles[particlePointer] = createParticle(caret.x, caret.y, caret.color);
            particlePointer = (particlePointer + 1) % 500;
          }
        } { // shake screen
          if (POWERMODE.shake) {
            var intensity = 1 + 2 * Math.random();
            var x = intensity * (Math.random() > 0.5 ? -1 : 1);
            var y = intensity * (Math.random() > 0.5 ? -1 : 1);
            document.body.style.marginLeft = x + 'px';
            document.body.style.marginTop = y + 'px';
            setTimeout(function () {
              document.body.style.marginLeft = '';
              document.body.style.marginTop = '';
            }, 75);
          }
        }
        if (!rendering) {
          requestAnimationFrame(loop);
        }
      };
      POWERMODE.colorful = false;

      function loop() {
        rendering = true;
        context.clearRect(0, 0, canvas.width, canvas.height);
        var rendered = false;
        var rect = canvas.getBoundingClientRect();
        for (var i = 0; i < particles.length; ++i) {
          var particle = particles[i];
          if (particle.alpha <= 0.1) continue;
          particle.velocity.y += 0.075;
          particle.x += particle.velocity.x;
          particle.y += particle.velocity.y;
          particle.alpha *= 0.96;
          context.globalAlpha = particle.alpha;
          context.fillStyle = particle.color;
          context.fillRect(
            Math.round(particle.x - 1.5) - rect.left,
            Math.round(particle.y - 1.5) - rect.top,
            3, 3
          );
          rendered = true;
        }
        if (rendered) {
          requestAnimationFrame(loop);
        } else {
          rendering = false;
        }
      }

      module.exports = POWERMODE;

      /***/
    }),
    /* 1 */
    /***/
    (function (module, exports) {

      /* jshint browser: true */

      (function () {

        // The properties that we copy into a mirrored div.
        // Note that some browsers, such as Firefox,
        // do not concatenate properties, i.e. padding-top, bottom etc. -> padding,
        // so we have to do every single property specifically.
        var properties = [
          'direction', // RTL support
          'boxSizing',
          'width', // on Chrome and IE, exclude the scrollbar, so the mirror div wraps exactly as the textarea does
          'height',
          'overflowX',
          'overflowY', // copy the scrollbar for IE
          'borderTopWidth',
          'borderRightWidth',
          'borderBottomWidth',
          'borderLeftWidth',
          'borderStyle',
          'paddingTop',
          'paddingRight',
          'paddingBottom',
          'paddingLeft',
          // https://developer.mozilla.org/en-US/docs/Web/CSS/font
          'fontStyle',
          'fontVariant',
          'fontWeight',
          'fontStretch',
          'fontSize',
          'fontSizeAdjust',
          'lineHeight',
          'fontFamily',
          'textAlign',
          'textTransform',
          'textIndent',
          'textDecoration', // might not make a difference, but better be safe
          'letterSpacing',
          'wordSpacing',
          'tabSize',
          'MozTabSize'
        ];

        var isFirefox = window.mozInnerScreenX != null;

        function getCaretCoordinates(element, position, options) {

          var debug = options && options.debug || false;
          if (debug) {
            var el = document.querySelector('#input-textarea-caret-position-mirror-div');
            if (el) {
              el.parentNode.removeChild(el);
            }
          }

          // mirrored div
          var div = document.createElement('div');
          div.id = 'input-textarea-caret-position-mirror-div';
          document.body.appendChild(div);

          var style = div.style;
          var computed = window.getComputedStyle ? getComputedStyle(element) : element.currentStyle; // currentStyle for IE < 9

          // default textarea styles
          style.whiteSpace = 'pre-wrap';
          if (element.nodeName !== 'INPUT')
            style.wordWrap = 'break-word'; // only for textarea-s

          // position off-screen
          style.position = 'absolute'; // required to return coordinates properly
          if (!debug)
            style.visibility = 'hidden'; // not 'display: none' because we want rendering

          // transfer the element's properties to the div
          properties.forEach(function (prop) {
            style[prop] = computed[prop];
          });

          if (isFirefox) {
            // Firefox lies about the overflow property for textareas: https://bugzilla.mozilla.org/show_bug.cgi?id=984275
            if (element.scrollHeight > parseInt(computed.height))
              style.overflowY = 'scroll';
          } else {
            style.overflow = 'hidden'; // for Chrome to not render a scrollbar; IE keeps overflowY = 'scroll'
          }

          div.textContent = element.value.substring(0, position);
          // the second special handling for input type="text" vs textarea: spaces need to be replaced with non-breaking spaces - http://stackoverflow.com/a/13402035/1269037
          if (element.nodeName === 'INPUT')
            div.textContent = div.textContent.replace(/\s/g, "\u00a0");

          var span = document.createElement('span');
          // Wrapping must be replicated *exactly*, including when a long word gets
          // onto the next line, with whitespace at the end of the line before (#7).
          // The  *only* reliable way to do that is to copy the *entire* rest of the
          // textarea's content into the <span> created at the caret position.
          // for inputs, just '.' would be enough, but why bother?
          span.textContent = element.value.substring(position) || '.'; // || because a completely empty faux span doesn't render at all
          div.appendChild(span);

          var coordinates = {
            top: span.offsetTop + parseInt(computed['borderTopWidth']),
            left: span.offsetLeft + parseInt(computed['borderLeftWidth'])
          };

          if (debug) {
            span.style.backgroundColor = '#aaa';
          } else {
            document.body.removeChild(div);
          }

          return coordinates;
        }

        if (typeof module != "undefined" && typeof module.exports != "undefined") {
          module.exports = getCaretCoordinates;
        } else {
          window.getCaretCoordinates = getCaretCoordinates;
        }

      }());

      /***/
    })
    /******/
  ])
});;
